/*   1:    */ package org.jetbrains.jps.model.serialization;
/*   2:    */ 
/*   3:    */

import com.intellij.openapi.diagnostic.Logger;
import com.intellij.openapi.util.JDOMUtil;
import com.intellij.openapi.util.Pair;
import com.intellij.openapi.util.io.FileUtil;
import com.intellij.openapi.util.io.FileUtilRt;
import com.intellij.util.ArrayUtil;
import com.intellij.util.concurrency.BoundedTaskExecutor;
import org.jdom.Element;
import org.jetbrains.annotations.NotNull;
import org.jetbrains.annotations.Nullable;
import org.jetbrains.jps.TimingLog;
import org.jetbrains.jps.model.JpsDummyElement;
import org.jetbrains.jps.model.JpsElement;
import org.jetbrains.jps.model.JpsElementFactory;
import org.jetbrains.jps.model.JpsProject;
import org.jetbrains.jps.model.java.JpsJavaModuleType;
import org.jetbrains.jps.model.library.sdk.JpsSdkType;
import org.jetbrains.jps.model.module.JpsModule;
import org.jetbrains.jps.model.module.JpsModuleType;
import org.jetbrains.jps.model.serialization.artifact.JpsArtifactSerializer;
import org.jetbrains.jps.model.serialization.facet.JpsFacetSerializer;
import org.jetbrains.jps.model.serialization.impl.JpsModuleSerializationDataExtensionImpl;
import org.jetbrains.jps.model.serialization.impl.JpsProjectSerializationDataExtensionImpl;
import org.jetbrains.jps.model.serialization.library.JpsLibraryTableSerializer;
import org.jetbrains.jps.model.serialization.library.JpsSdkTableSerializer;
import org.jetbrains.jps.model.serialization.module.JpsModuleClasspathSerializer;
import org.jetbrains.jps.model.serialization.module.JpsModulePropertiesSerializer;
import org.jetbrains.jps.model.serialization.module.JpsModuleRootModelSerializer;
import org.jetbrains.jps.model.serialization.runConfigurations.JpsRunConfigurationSerializer;
import org.jetbrains.jps.service.SharedThreadPool;

import java.io.File;
import java.io.FileFilter;
import java.io.IOException;
import java.util.ArrayList;
import java.util.Iterator;
import java.util.List;
import java.util.Map;
import java.util.concurrent.Callable;
import java.util.concurrent.Future;

/*   4:    */
/*   5:    */
/*   6:    */
/*   7:    */
/*   8:    */
/*   9:    */
/*  10:    */
/*  11:    */
/*  12:    */
/*  13:    */
/*  14:    */
/*  15:    */
/*  16:    */
/*  17:    */
/*  18:    */
/*  19:    */
/*  20:    */
/*  21:    */
/*  22:    */
/*  23:    */
/*  24:    */
/*  25:    */
/*  26:    */
/*  27:    */
/*  28:    */
/*  29:    */
/*  30:    */
/*  31:    */
/*  32:    */
/*  33:    */
/*  34:    */
/*  35:    */
/*  36:    */
/*  37:    */
/*  38:    */
/*  39:    */
/*  40:    */
/*  41:    */
/*  42:    */
/*  43:    */ 
/*  44:    */ public class JpsProjectLoader
/*  45:    */   extends JpsLoaderBase
/*  46:    */ {
/*  47: 61 */   private static final Logger b = Logger.getInstance(JpsProjectLoader.class);
/*  48: 62 */   private static final BoundedTaskExecutor c = new BoundedTaskExecutor(SharedThreadPool.getInstance(), Runtime.getRuntime().availableProcessors());
/*  49:    */   public static final String CLASSPATH_ATTRIBUTE = "classpath";
/*  50:    */   public static final String CLASSPATH_DIR_ATTRIBUTE = "classpath-dir";
/*  51:    */   private final JpsProject d;
/*  52:    */   private final Map<String, String> e;
/*  53:    */   
/*  54:    */   private JpsProjectLoader(JpsProject paramJpsProject, Map<String, String> paramMap, File paramFile)
/*  55:    */   {
/*  56: 69 */     super(createProjectMacroExpander(paramMap, paramFile));
/*  57: 70 */     this.d = paramJpsProject;
/*  58: 71 */     this.e = paramMap;
/*  59: 72 */     this.d.getContainer().setChild(JpsProjectSerializationDataExtensionImpl.ROLE, new JpsProjectSerializationDataExtensionImpl(paramFile));
/*  60:    */   }
/*  61:    */   
/*  62:    */   static JpsMacroExpander createProjectMacroExpander(Map<String, String> paramMap, File paramFile)
/*  63:    */   {
/*  64: 76 */     JpsMacroExpander localJpsMacroExpander = new JpsMacroExpander(paramMap);
/*  65: 77 */     localJpsMacroExpander.addFileHierarchyReplacements("PROJECT_DIR", paramFile);
/*  66: 78 */     return localJpsMacroExpander;
/*  67:    */   }
/*  68:    */   
/*  69:    */   public static void loadProject(JpsProject paramJpsProject, Map<String, String> paramMap, String paramString)
/*  70:    */     throws IOException
/*  71:    */   {
/*  72: 82 */     File localFile1 = new File(FileUtil.toCanonicalPath(paramString));
/*  73: 83 */     if ((localFile1.isFile()) && (paramString.endsWith(".ipr")))
/*  74:    */     {
/*  75: 84 */       new JpsProjectLoader(paramJpsProject, paramMap, localFile1.getParentFile()).c(localFile1);
/*  76:    */     }
/*  77:    */     else
/*  78:    */     {
/*  79: 87 */       File localFile2 = new File(localFile1, ".idea");
/*  80:    */       File localFile3;
/*  81: 89 */       if (localFile2.isDirectory()) {
/*  82: 90 */         localFile3 = localFile2;
/*  83: 92 */       } else if ((localFile1.isDirectory()) && (localFile1.getName().equals(".idea"))) {
/*  84: 93 */         localFile3 = localFile1;
/*  85:    */       } else {
/*  86: 96 */         throw new IOException("Cannot find IntelliJ IDEA project files at " + paramString);
/*  87:    */       }
/*  88: 98 */       new JpsProjectLoader(paramJpsProject, paramMap, localFile3.getParentFile()).a(localFile3);
/*  89:    */     }
/*  90:    */   }
/*  91:    */   
/*  92:    */   public static String getDirectoryBaseProjectName(File paramFile)
/*  93:    */   {
/*  94:103 */     File localFile = new File(paramFile, ".name");
/*  95:104 */     if (localFile.isFile()) {
/*  96:    */       try
/*  97:    */       {
/*  98:106 */         return FileUtilRt.loadFile(localFile).trim();
/*  99:    */       }
/* 100:    */       catch (IOException localIOException) {}
/* 101:    */     }
/* 102:111 */     return paramFile.getParentFile().getName();
/* 103:    */   }
/* 104:    */   
/* 105:    */   private void a(File paramFile)
/* 106:    */   {
/* 107:115 */     this.d.setName(getDirectoryBaseProjectName(paramFile));
/* 108:116 */     JpsSdkType localJpsSdkType = b(loadRootElement(new File(paramFile, "misc.xml")));
/* 109:117 */     for (Object localObject1 = JpsModelSerializerExtension.getExtensions().iterator(); ((Iterator)localObject1).hasNext();)
/* 110:    */     {
/* 111:117 */       localObject2 = (JpsModelSerializerExtension)((Iterator)localObject1).next();
/* 112:118 */       for (JpsProjectExtensionSerializer localJpsProjectExtensionSerializer : ((JpsModelSerializerExtension)localObject2).getProjectExtensionSerializers()) {
/* 113:119 */         loadComponents(paramFile, "misc.xml", localJpsProjectExtensionSerializer, this.d);
/* 114:    */       }
/* 115:    */     }
/* 116:122 */     a(loadRootElement(new File(paramFile, "modules.xml")), localJpsSdkType);
/* 117:    */     
/* 118:124 */     localObject1 = TimingLog.startActivity("loading project libraries");
/* 119:125 */     for (File localFile1 : b(new File(paramFile, "libraries"))) {
/* 120:126 */       c(loadRootElement(localFile1));
/* 121:    */     }
/* 122:128 */     ((Runnable)localObject1).run();
/* 123:    */     
/* 124:130 */     Object localObject2 = TimingLog.startActivity("loading artifacts");
/* 125:131 */     for (File localFile2 : b(new File(paramFile, "artifacts"))) {
/* 126:132 */       a(loadRootElement(localFile2));
/* 127:    */     }
/* 128:134 */     ((Runnable)localObject2).run();
/* 129:136 */     if (a())
/* 130:    */     {
/* 131:137 */       ??? = TimingLog.startActivity("loading artifacts");
/* 132:138 */       for (File localFile3 : b(new File(paramFile, "runConfigurations"))) {
/* 133:139 */         JpsRunConfigurationSerializer.loadRunConfigurations(this.d, loadRootElement(localFile3));
/* 134:    */       }
/* 135:141 */       ??? = new File(paramFile, "workspace.xml");
/* 136:142 */       if (((File)???).exists())
/* 137:    */       {
/* 138:143 */         Element localElement = JDomSerializationUtil.findComponent(loadRootElement((File)???), "RunManager");
/* 139:144 */         JpsRunConfigurationSerializer.loadRunConfigurations(this.d, localElement);
/* 140:    */       }
/* 141:146 */       ((Runnable)???).run();
/* 142:    */     }
/* 143:    */   }
/* 144:    */   
/* 145:    */   private static boolean a()
/* 146:    */   {
/* 147:151 */     for (JpsModelSerializerExtension localJpsModelSerializerExtension : ) {
/* 148:152 */       if (!localJpsModelSerializerExtension.getRunConfigurationPropertiesSerializers().isEmpty()) {
/* 149:153 */         return true;
/* 150:    */       }
/* 151:    */     }
/* 152:156 */     return false;
/* 153:    */   }
/* 154:    */   
/* 155:    */   @NotNull
/* 156:    */   private static File[] b(File paramFile)
/* 157:    */   {
/* 158:161 */     File[] arrayOfFile = paramFile.listFiles(new FileFilter()
/* 159:    */     {
/* 160:    */       public boolean accept(File paramAnonymousFile)
/* 161:    */       {
/* 162:164 */         return JpsLoaderBase.isXmlFile(paramAnonymousFile);
/* 163:    */       }
/* 164:167 */     }); File[] tmp23_20 = (arrayOfFile != null ? arrayOfFile : ArrayUtil.EMPTY_FILE_ARRAY);
/* 165:167 */     if (tmp23_20 == null) {
/* 166:167 */       throw new IllegalStateException(String.format("@NotNull method %s.%s must not return null", new Object[] { "org/jetbrains/jps/model/serialization/JpsProjectLoader", "listXmlFiles" }));
/* 167:    */     }
/* 168:167 */     return tmp23_20;
/* 169:    */   }
/* 170:    */   
/* 171:    */   private void c(File paramFile)
/* 172:    */   {
/* 173:171 */     Element localElement1 = loadRootElement(paramFile);
/* 174:    */     
/* 175:173 */     String str = FileUtil.getNameWithoutExtension(paramFile);
/* 176:174 */     this.d.setName(str);
/* 177:175 */     File localFile = new File(paramFile.getParent(), str + ".iws");
/* 178:176 */     Element localElement2 = localFile.exists() ? loadRootElement(localFile) : null;
/* 179:    */     
/* 180:178 */     JpsSdkType localJpsSdkType = b(localElement1);
/* 181:179 */     for (JpsModelSerializerExtension localJpsModelSerializerExtension : JpsModelSerializerExtension.getExtensions()) {
/* 182:180 */       for (JpsProjectExtensionSerializer localJpsProjectExtensionSerializer : localJpsModelSerializerExtension.getProjectExtensionSerializers())
/* 183:    */       {
/* 184:181 */         Element localElement3 = "workspace.xml".equals(localJpsProjectExtensionSerializer.getConfigFileName()) ? localElement2 : localElement1;
/* 185:182 */         Element localElement4 = JDomSerializationUtil.findComponent(localElement3, localJpsProjectExtensionSerializer.getComponentName());
/* 186:183 */         if (localElement4 != null) {
/* 187:184 */           localJpsProjectExtensionSerializer.loadExtension(this.d, localElement4);
/* 188:    */         } else {
/* 189:187 */           localJpsProjectExtensionSerializer.loadExtensionWithDefaultSettings(this.d);
/* 190:    */         }
/* 191:    */       }
/* 192:    */     }
/* 193:191 */     a(localElement1, localJpsSdkType);
/* 194:192 */     c(JDomSerializationUtil.findComponent(localElement1, "libraryTable"));
/* 195:193 */     a(JDomSerializationUtil.findComponent(localElement1, "ArtifactManager"));
/* 196:194 */     if (a())
/* 197:    */     {
/* 198:195 */       JpsRunConfigurationSerializer.loadRunConfigurations(this.d, JDomSerializationUtil.findComponent(localElement1, "ProjectRunConfigurationManager"));
/* 199:196 */       JpsRunConfigurationSerializer.loadRunConfigurations(this.d, JDomSerializationUtil.findComponent(localElement2, "RunManager"));
/* 200:    */     }
/* 201:    */   }
/* 202:    */   
/* 203:    */   private void a(@Nullable Element paramElement)
/* 204:    */   {
/* 205:201 */     JpsArtifactSerializer.loadArtifacts(this.d, paramElement);
/* 206:    */   }
/* 207:    */   
/* 208:    */   @Nullable
/* 209:    */   private JpsSdkType<?> b(Element paramElement)
/* 210:    */   {
/* 211:206 */     JpsSdkType localJpsSdkType = null;
/* 212:207 */     Element localElement = JDomSerializationUtil.findComponent(paramElement, "ProjectRootManager");
/* 213:208 */     if (localElement != null)
/* 214:    */     {
/* 215:209 */       String str1 = localElement.getAttributeValue("project-jdk-name");
/* 216:210 */       String str2 = localElement.getAttributeValue("project-jdk-type");
/* 217:211 */       if (str1 != null)
/* 218:    */       {
/* 219:212 */         localJpsSdkType = JpsSdkTableSerializer.getSdkType(str2);
/* 220:213 */         JpsSdkTableSerializer.setSdkReference(this.d.getSdkReferencesTable(), str1, localJpsSdkType);
/* 221:    */       }
/* 222:    */     }
/* 223:216 */     return localJpsSdkType;
/* 224:    */   }
/* 225:    */   
/* 226:    */   private void c(@Nullable Element paramElement)
/* 227:    */   {
/* 228:220 */     JpsLibraryTableSerializer.loadLibraries(paramElement, this.d.getLibraryCollection());
/* 229:    */   }
/* 230:    */   
/* 231:    */   private void a(Element paramElement, @Nullable final JpsSdkType<?> paramJpsSdkType)
/* 232:    */   {
/* 233:224 */     Runnable localRunnable = TimingLog.startActivity("loading modules");
/* 234:225 */     Element localElement1 = JDomSerializationUtil.findComponent(paramElement, "ProjectModuleManager");
/* 235:226 */     if (localElement1 == null) {
/* 236:226 */       return;
/* 237:    */     }
/* 238:227 */     Element localElement2 = localElement1.getChild("modules");
/* 239:228 */     ArrayList localArrayList1 = new ArrayList();
/* 240:    */     
/* 241:230 */     ArrayList localArrayList2 = new ArrayList();
/* 242:231 */     for (Object localObject1 = JDOMUtil.getChildren(localElement2, "module").iterator(); ((Iterator)localObject1).hasNext();)
/* 243:    */     {
/* 244:231 */       localObject2 = (Element)((Iterator)localObject1).next();
/* 245:232 */       localObject3 = ((Element)localObject2).getAttributeValue("filepath");
/* 246:233 */       localObject4 = new File((String)localObject3);
/* 247:234 */       if (!((File)localObject4).exists()) {
/* 248:235 */         b.info("Module '" + FileUtil.getNameWithoutExtension((File)localObject4) + "' is skipped: " + ((File)localObject4).getAbsolutePath() + " doesn't exist");
/* 249:    */       } else {
/* 250:239 */         localArrayList2.add(c.submit(new Callable()
/* 251:    */         {
/* 252:    */           public Pair<File, Element> call()
/* 253:    */             throws Exception
/* 254:    */           {
/* 255:242 */             JpsMacroExpander localJpsMacroExpander = JpsProjectLoader.createModuleMacroExpander(JpsProjectLoader.this.e, this.val$file);
/* 256:243 */             Element localElement = JpsLoaderBase.loadRootElement(this.val$file, localJpsMacroExpander);
/* 257:244 */             return Pair.create(this.val$file, localElement);
/* 258:    */           }
/* 259:    */         }));
/* 260:    */       }
/* 261:    */     }
/* 262:    */     try
/* 263:    */     {
/* 264:250 */       localObject1 = new ArrayList();
/* 265:251 */       for (localObject2 = localArrayList2.iterator(); ((Iterator)localObject2).hasNext();)
/* 266:    */       {
/* 267:251 */         localObject3 = (Future)((Iterator)localObject2).next();
/* 268:252 */         localObject4 = ((Element)((Pair)((Future)localObject3).get()).getSecond()).getAttributeValue("classpath-dir");
/* 269:253 */         if (localObject4 != null) {
/* 270:254 */           ((List)localObject1).add(localObject4);
/* 271:    */         }
/* 272:    */       }
/* 273:258 */       for (localObject2 = localArrayList2.iterator(); ((Iterator)localObject2).hasNext();)
/* 274:    */       {
/* 275:258 */         localObject3 = (Future)((Iterator)localObject2).next();
/* 276:259 */         localObject4 = (Pair)((Future)localObject3).get();
/* 277:260 */         localArrayList1.add(c.submit(new Callable()
/* 278:    */         {
/* 279:    */           public JpsModule call()
/* 280:    */             throws Exception
/* 281:    */           {
/* 282:263 */             return JpsProjectLoader.this.a((File)this.val$moduleFile.getFirst(), (Element)this.val$moduleFile.getSecond(), this.val$classpathDirs, paramJpsSdkType);
/* 283:    */           }
/* 284:    */         }));
/* 285:    */       }
/* 286:267 */       for (localObject2 = localArrayList1.iterator(); ((Iterator)localObject2).hasNext();)
/* 287:    */       {
/* 288:267 */         localObject3 = (Future)((Iterator)localObject2).next();
/* 289:268 */         localObject4 = (JpsModule)((Future)localObject3).get();
/* 290:269 */         if (localObject4 != null) {
/* 291:270 */           this.d.addModule((JpsModule)localObject4);
/* 292:    */         }
/* 293:    */       }
/* 294:    */     }
/* 295:    */     catch (Exception localException)
/* 296:    */     {
/* 297:    */       Object localObject2;
/* 298:    */       Object localObject3;
/* 299:    */       Object localObject4;
/* 300:275 */       throw new RuntimeException(localException);
/* 301:    */     }
/* 302:277 */     localRunnable.run();
/* 303:    */   }
/* 304:    */   
/* 305:    */   @Nullable
/* 306:    */   private JpsModule a(@NotNull File paramFile, @NotNull Element paramElement, List<String> paramList, @Nullable JpsSdkType<?> paramJpsSdkType)
/* 307:    */   {
/* 308:282 */     if (paramFile == null) {
/* 309:282 */       throw new IllegalArgumentException(String.format("Argument %s for @NotNull parameter of %s.%s must not be null", new Object[] { "0", "org/jetbrains/jps/model/serialization/JpsProjectLoader", "loadModule" }));
/* 310:    */     }
/* 311:282 */     if (paramElement == null) {
/* 312:282 */       throw new IllegalArgumentException(String.format("Argument %s for @NotNull parameter of %s.%s must not be null", new Object[] { "1", "org/jetbrains/jps/model/serialization/JpsProjectLoader", "loadModule" }));
/* 313:    */     }
/* 314:282 */     String str1 = FileUtil.getNameWithoutExtension(paramFile);
/* 315:283 */     String str2 = paramElement.getAttributeValue("type");
/* 316:284 */     JpsModulePropertiesSerializer localJpsModulePropertiesSerializer = a(str2);
/* 317:285 */     JpsModule localJpsModule = a(str1, paramElement, localJpsModulePropertiesSerializer);
/* 318:286 */     localJpsModule.getContainer().setChild(JpsModuleSerializationDataExtensionImpl.ROLE, new JpsModuleSerializationDataExtensionImpl(paramFile.getParentFile()));
/* 319:289 */     for (Object localObject1 = JpsModelSerializerExtension.getExtensions().iterator(); ((Iterator)localObject1).hasNext();)
/* 320:    */     {
/* 321:289 */       localObject2 = (JpsModelSerializerExtension)((Iterator)localObject1).next();
/* 322:290 */       ((JpsModelSerializerExtension)localObject2).loadModuleOptions(localJpsModule, paramElement);
/* 323:    */     }
/* 324:293 */     localObject1 = FileUtil.toSystemIndependentName(paramFile.getParent());
/* 325:294 */     Object localObject2 = paramElement.getAttributeValue("classpath");
/* 326:295 */     if (localObject2 == null) {
/* 327:296 */       JpsModuleRootModelSerializer.loadRootModel(localJpsModule, JDomSerializationUtil.findComponent(paramElement, "NewModuleRootManager"), paramJpsSdkType);
/* 328:    */     } else {
/* 329:300 */       for (JpsModelSerializerExtension localJpsModelSerializerExtension : JpsModelSerializerExtension.getExtensions())
/* 330:    */       {
/* 331:301 */         JpsModuleClasspathSerializer localJpsModuleClasspathSerializer = localJpsModelSerializerExtension.getClasspathSerializer();
/* 332:302 */         if ((localJpsModuleClasspathSerializer != null) && (localJpsModuleClasspathSerializer.getClasspathId().equals(localObject2)))
/* 333:    */         {
/* 334:303 */           String str3 = paramElement.getAttributeValue("classpath-dir");
/* 335:304 */           JpsMacroExpander localJpsMacroExpander = createModuleMacroExpander(this.e, paramFile);
/* 336:305 */           localJpsModuleClasspathSerializer.loadClasspath(localJpsModule, str3, (String)localObject1, localJpsMacroExpander, paramList, paramJpsSdkType);
/* 337:    */         }
/* 338:    */       }
/* 339:    */     }
/* 340:309 */     JpsFacetSerializer.loadFacets(localJpsModule, JDomSerializationUtil.findComponent(paramElement, "FacetManager"));
/* 341:310 */     return localJpsModule;
/* 342:    */   }
/* 343:    */   
/* 344:    */   static JpsMacroExpander createModuleMacroExpander(Map<String, String> paramMap, File paramFile)
/* 345:    */   {
/* 346:314 */     JpsMacroExpander localJpsMacroExpander = new JpsMacroExpander(paramMap);
/* 347:315 */     String str = PathMacroUtil.getModuleDir(paramFile.getAbsolutePath());
/* 348:316 */     if (str != null) {
/* 349:317 */       localJpsMacroExpander.addFileHierarchyReplacements("MODULE_DIR", new File(FileUtil.toSystemDependentName(str)));
/* 350:    */     }
/* 351:319 */     return localJpsMacroExpander;
/* 352:    */   }
/* 353:    */   
/* 354:    */   private static <P extends JpsElement> JpsModule a(String paramString, Element paramElement, JpsModulePropertiesSerializer<P> paramJpsModulePropertiesSerializer)
/* 355:    */   {
/* 356:323 */     String str = paramJpsModulePropertiesSerializer.getComponentName();
/* 357:324 */     Element localElement = str != null ? JDomSerializationUtil.findComponent(paramElement, str) : null;
/* 358:325 */     return JpsElementFactory.getInstance().createModule(paramString, (JpsModuleType)paramJpsModulePropertiesSerializer.getType(), paramJpsModulePropertiesSerializer.loadProperties(localElement));
/* 359:    */   }
/* 360:    */   
/* 361:    */   private static JpsModulePropertiesSerializer<?> a(@Nullable String paramString)
/* 362:    */   {
/* 363:329 */     for (JpsModelSerializerExtension localJpsModelSerializerExtension : ) {
/* 364:330 */       for (JpsModulePropertiesSerializer localJpsModulePropertiesSerializer : localJpsModelSerializerExtension.getModulePropertiesSerializers()) {
/* 365:331 */         if (localJpsModulePropertiesSerializer.getTypeId().equals(paramString)) {
/* 366:332 */           return localJpsModulePropertiesSerializer;
/* 367:    */         }
/* 368:    */       }
/* 369:    */     }
/* 370:336 */     new JpsModulePropertiesSerializer(JpsJavaModuleType.INSTANCE, "JAVA_MODULE", null)
/* 371:    */     {
/* 372:    */       public JpsDummyElement loadProperties(@Nullable Element paramAnonymousElement)
/* 373:    */       {
/* 374:339 */         return JpsElementFactory.getInstance().createDummyElement();
/* 375:    */       }
/* 376:    */       
/* 377:    */       public void saveProperties(@NotNull JpsDummyElement paramAnonymousJpsDummyElement, @NotNull Element paramAnonymousElement)
/* 378:    */       {
/* 379:344 */         if (paramAnonymousJpsDummyElement == null) {
/* 380:344 */           throw new IllegalArgumentException(String.format("Argument %s for @NotNull parameter of %s.%s must not be null", new Object[] { "0", "org/jetbrains/jps/model/serialization/JpsProjectLoader$4", "saveProperties" }));
/* 381:    */         }
/* 382:344 */         if (paramAnonymousElement == null) {
/* 383:344 */           throw new IllegalArgumentException(String.format("Argument %s for @NotNull parameter of %s.%s must not be null", new Object[] { "1", "org/jetbrains/jps/model/serialization/JpsProjectLoader$4", "saveProperties" }));
/* 384:    */         }
/* 385:    */       }
/* 386:    */     };
/* 387:    */   }
/* 388:    */ }



/* Location:           E:\idea\

 * Qualified Name:     org.jetbrains.jps.model.serialization.JpsProjectLoader

 * JD-Core Version:    0.7.0.1

 */